home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / info-service / gopher / Unix / gopher+1.2b4 / gopherd / authenticate.c next >
Encoding:
C/C++ Source or Header  |  1993-04-09  |  15.4 KB  |  595 lines
  1. /********************************************************************
  2.  * lindner
  3.  * 3.5
  4.  * 1993/04/10 06:07:17
  5.  * /home/mudhoney/GopherSrc/CVS/gopher+/gopherd/authenticate.c,v
  6.  * Exp
  7.  *
  8.  * Paul Lindner, University of Minnesota CIS.
  9.  *
  10.  * Copyright 1991, 1992, 1993 by the Regents of the University of Minnesota
  11.  * see the file "Copyright" in the distribution for conditions of use.
  12.  *********************************************************************
  13.  * MODULE: authenticate.c
  14.  * Routines to do encryption and decryption, and validate tickets
  15.  *********************************************************************
  16.  * Revision History:
  17.  * authenticate.c,v
  18.  * Revision 3.5  1993/04/10  06:07:17  lindner
  19.  * none
  20.  *
  21.  * Revision 3.4  1993/04/09  16:51:54  lindner
  22.  * Little mods for combined public gopher and admit1 gopher.
  23.  *
  24.  * Revision 3.3  1993/04/07  05:16:57  lindner
  25.  * Unhid changes for Admit1 stuff.
  26.  *
  27.  * Revision 3.1  1993/03/19  20:02:13  lindner
  28.  * DES and ticket routines
  29.  *
  30.  *
  31.  *********************************************************************/
  32.  
  33.  
  34.  
  35. /* -------------------------------------------------
  36.  *
  37.  * Sofware DES functions 12 Dec 1986 by Phil Karn, KA9Q;
  38.  * large sections from 1977 public-domain program by Jim Gillogly
  39.  * Modified by George Gonzalez to not do initial/final permutations
  40.  * Further bludgeoned by Farhad Anklesaria for AdmitOne authentication.
  41.  *
  42.  ---------------------------------------------------- */
  43.  
  44. #define  SLEN 255  /* Generic small buffer length */
  45. extern int DEBUG;
  46.  
  47. static int IntelOrder;     /*Hacked out.  fxa*/
  48.  
  49. /* Tables defined in the Data Encryption Standard documents */
  50. /* permuted choice table (key) */
  51. static char pc1[] = {
  52.      57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
  53.      10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
  54.      
  55.      63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
  56.      14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
  57.      };
  58.  
  59. /* number left rotations of pc1 */
  60. static char totrot[] = { 1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 };
  61.  
  62. /* permuted choice key (table) */
  63. static char pc2[] = {
  64.      14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
  65.      23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
  66.      41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
  67.      44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
  68.      };
  69.  
  70. /* The (in)famous S-boxes */
  71. static char si[8][64] = {
  72.      /* S1 */
  73.      14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
  74.      0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
  75.      4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
  76.      15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13,
  77.      
  78.      /* S2 */
  79.      15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
  80.      3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
  81.      0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
  82.      13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9,
  83.      
  84.      /* S3 */
  85.      10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
  86.      13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
  87.      13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
  88.      1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12,
  89.      
  90.      /* S4 */
  91.      7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
  92.      13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
  93.      10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
  94.      3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14,
  95.      
  96.      /* S5 */
  97.      2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
  98.      14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
  99.      4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
  100.      11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3,
  101.      
  102.      /* S6 */
  103.      12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
  104.      10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
  105.      9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
  106.      4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13,
  107.      
  108.      /* S7 */
  109.      4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
  110.      13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
  111.      1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
  112.      6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12,
  113.      
  114.      /* S8 */
  115.      13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
  116.      1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
  117.      7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
  118.      2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
  119.      };
  120.  
  121. /* 32-bit permutation  P used on the output of the S-boxes */
  122. static char p32i[] = { 
  123.      16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,  5, 18, 31, 10,
  124.      2,  8, 24, 14, 32, 27,  3,  9, 19, 13, 30,  6, 22, 11,  4, 25
  125.      };
  126.  
  127. /* Lookup tables initialized once only at startup by desinit() */
  128.  
  129.  
  130.   
  131. /* bit 0 == left-most in byte */
  132. static short bytebit[] = { 0200,0100,0040,0020,0010,0004,0002,0001 };
  133.   
  134.   
  135. char ticket[SLEN] = "3135323020202020";  /* 1520 */
  136. char pw[SLEN] =     "61646D6974312020";  /* admit1 */
  137. char pt[SLEN] = "1520    ";  /* 1520 */
  138. char pt2[SLEN]; 
  139. unsigned long tNum;
  140.  
  141. static unsigned char (*kn)[8];
  142. static int (*spbox)[64]; /* Combined S && P boxes */
  143.   
  144. /*-------------MAIN--------------*/
  145. #ifdef ADMIT1TEST
  146.  
  147. int DEBUG = 1;
  148. Abort()
  149. {
  150.      exit(-1);
  151. }
  152.  
  153. main(argc, argv)
  154.   int argc;
  155.   char * argv[];
  156. {
  157.      unsigned long out[3];
  158.      
  159.      printf("ick.  here we go.\n");
  160.      tNum = atoi(pt);
  161.      printf("tNum converted from string: %d\n", tNum);
  162.      sprintf(pt2, "%X%X%X%X%X%X%X%X", pt[0],pt[1],pt[2],pt[3],pt[4],pt[5],pt[6],pt[7] );
  163.      printf("pt2 converted to hex from str: %s\n", pt2);
  164.      printf("Ticket: %s\n", ticket);
  165.      printf("pw: %s\n", pw);
  166.      encrypt(ticket, pw, out );
  167.      sprintf(ticket, "%.8lX%.8lX", out[0], out[1]);
  168.      printf("converted to string: %s\n", ticket);
  169.      decrypt(ticket, pw, out);
  170.      
  171.      decrypt("374506700551A6B6", pw, out);
  172.      
  173.      if ( desinit() == 0 ) desdone();
  174. }
  175.  
  176. #endif
  177.  
  178. /*--------------------------------*/
  179. /* Initialize the lookup table for the combined S && P boxes */
  180. void spinit()
  181. {
  182.      char pbox[ 32 ];
  183.      short p, i, s, j, t, rowcol;
  184.      int val;
  185.      
  186.      for ( p = 1; p <= 32; p++ ) {
  187.       for ( i = 0; i <= 31; i++ ) {
  188.            if ( p32i[ i ] == p ) {
  189.             pbox[ p - 1 ] = 31 - i;
  190.             break;
  191.            }
  192.       }
  193.      }
  194.      for ( s = 0; s <= 7; s++ ) {
  195.       for ( i = 0; i <= 63; i++ ) {
  196.            val = 0;
  197.            rowcol = (i & 32) | ((i & 1) ? 16 : 0) | ((i >> 1) & 0xf);
  198.            t = si[ s ] [ rowcol ];
  199.            for ( j = 0; j <= 3; j++ ) {
  200.             if ( t & ( 8 >> j ) ) {
  201.              val |= 1L << pbox[ ( s << 2 ) + j ];
  202.             }
  203.            }
  204.            spbox[ s ] [ i ] = val;
  205.       }
  206.      }
  207. }
  208.  
  209.  
  210. /*--------------------------------*/
  211. /* Allocate space && initialize DES lookup arrays
  212.  * mode == 1: DEA without initial && final permutations for speed
  213.  */
  214.  
  215. desinit()
  216. {
  217.      if ( spbox != 0 ) return 0; 
  218.      
  219.      spbox = ( int (*)[64] ) malloc( sizeof( int ) * 8 * 64);
  220.      if ( spbox != 0) { 
  221.       spinit();
  222.       kn = (unsigned char (*)[8]) malloc( sizeof( char ) * 8 * 16);
  223.       if ( kn == 0 ) {
  224.            free( (char *) spbox );
  225.            spbox = 0;
  226.       } 
  227.      }
  228.      if ( spbox == 0 || kn == 0 ) {
  229.       return -1;
  230.      } else {
  231.       return 0;
  232.      }
  233. }
  234.  
  235. /*--------------------------------*/
  236. /* Free up storage used by DES */
  237.  
  238. desdone()
  239. { 
  240.      if (spbox != 0) {
  241.       free( (char *) spbox );
  242.       free( (char *) kn );
  243.       spbox = 0;
  244.       kn = 0;
  245.      }
  246. }
  247.  
  248.  
  249. /*--------------------------------*/
  250.  
  251. void setdeskey( key ) char * key;
  252. {
  253.      char pc1m[56];  /* place to modify pc1 into */
  254.      char pcr[56];  /* place to rotate pc1 into */
  255.      register short i, j, k;
  256.      
  257.      /* Clear key schedule */
  258.      for (i=0; i<16; i++) {
  259.       for (j=0; j<8; j++) {
  260.            kn[i][j]=0;
  261.       }
  262.      }
  263.      
  264.      for (j=0; j<56; j++) {  /* convert pc1 to bits of key */
  265.       k = pc1[ j ] - 1;
  266.       pc1m[ j ] = ( key[ k >> 3 ]  & bytebit[ k & 07 ]) ? 1 : 0;
  267.      } 
  268.      
  269.      for (i=0; i<16; i++) {  /* key chunk for each iteration */
  270.       for (j=0; j<56; j++) { /* rotate pc1 the right amount */
  271.            k = j + totrot[ i ];
  272.            pcr[ j ] = pc1m[ k < ( j < 28 ? 28 : 56 ) ? k : k - 28 ];
  273.       }
  274.       for (j=0; j<48; j++) { /* select bits individually */
  275.            if ( pcr[ pc2[ j ] - 1 ] ) {
  276.             kn[ i ] [ j / 6 ] |= bytebit[ j % 6 ] >> 2;
  277.            }
  278.       }
  279.      }
  280. }
  281.  
  282.  
  283. /*--------------------------------*/
  284.  
  285. void byteswap( x ) 
  286.   unsigned long * x;
  287. {
  288.      register char * cp;
  289.      register char tmp;
  290.      
  291.      cp = (char *) x;
  292.      tmp = cp[3];
  293.      cp[3] = cp[0];
  294.      cp[0] = tmp;
  295.      
  296.      tmp = cp[2];
  297.      cp[2] = cp[1];
  298.      cp[1] = tmp;
  299. }
  300.  
  301.  
  302. /*--------------------------------*/
  303.  
  304. void mv( in, out ) char * in, *out;
  305. {  short i;
  306.    
  307.    for ( i = 0; i <= 7; i++ ) out[i] = in[i];
  308.    if ( IntelOrder ) {
  309.     byteswap( (unsigned long * ) &out[0] );
  310.     byteswap( (unsigned long * ) &out[4] );
  311.    }
  312. }
  313.  
  314.  
  315. /*--------------------------------*/
  316. /* The nonlinear  f(r,k), the heart of DES */
  317.  
  318. int f( r, subkey ) unsigned long r; unsigned char subkey[8];
  319. {
  320.      register unsigned long rval, rt;
  321.      
  322.      /* Run E(R) ^ K through the combined S & P boxes
  323.       * This ; takes advantage of a convenient regularity in
  324.       * E, namely that each group of 6 bits in E(R) feeding
  325.       * a single S-box == a contiguous segment of R.
  326.       */
  327.      rt = (r >> 1) | ((r & 1) ? 0x80000000 : 0);
  328.      rval = 0;
  329.      rval |= spbox[0][((rt >> 26) ^ *subkey++) & 0x3f];
  330.      rval |= spbox[1][((rt >> 22) ^ *subkey++) & 0x3f];
  331.      rval |= spbox[2][((rt >> 18) ^ *subkey++) & 0x3f];
  332.      rval |= spbox[3][((rt >> 14) ^ *subkey++) & 0x3f];
  333.      rval |= spbox[4][((rt >> 10) ^ *subkey++) & 0x3f];
  334.      rval |= spbox[5][((rt >> 6) ^ *subkey++) & 0x3f];
  335.      rval |= spbox[6][((rt >> 2) ^ *subkey++) & 0x3f];
  336.      rt = (r << 1) | ((r & 0x80000000) ? 1 : 0);
  337.      rval |= spbox[7][(rt ^ *subkey) & 0x3f];
  338.      return rval;
  339. }
  340.  
  341. /*--------------------------------*/
  342.  
  343. void pass( num, block ) short num; unsigned long *block;
  344. {
  345.      short b;
  346.      
  347.      b = num & 1;
  348.      block[ b ] ^= f( block[ 1 - b ], kn[ num ] );
  349. }
  350.  
  351.  
  352.  
  353.  
  354. /*--------------------------------*/
  355. /* In-place encryption of 64-bit block */
  356.  
  357. void endes(block) 
  358.   unsigned long * block;
  359. {
  360.      register short i;
  361.      unsigned long work[3];   /* Working data storage */
  362.      int tmp;
  363.      
  364.      mv( ( char * ) block, (char * ) work ); /* Initial Permutation */
  365.      for (i=0; i<16; i++)
  366.       pass( i, work );
  367.      tmp = work[0];
  368.      work[0] = work[1]; 
  369.      work[1] = tmp;
  370.      mv( (char *) work, (char *) block );
  371. }
  372.  
  373.  
  374.  
  375. /*--------------------------------*/
  376. /* In-place decryption of 64-bit block */
  377. void dedes(block) 
  378.   unsigned long * block;
  379. {
  380.      register short i;
  381.      unsigned long work[3]; /* Working data storage */
  382.      int tmp;
  383.      ;
  384.      mv( (char * ) block, (char *) work ); /* Initial permutation */
  385.      
  386.      /* Left/right half swap */
  387.      tmp = work[0];
  388.      work[0] = work[1]; 
  389.      work[1] = tmp;
  390.      
  391.      /* Do the 16 rounds in reverse order */
  392.      for ( i = 0; i <=15; i++ )
  393.       pass( 15 - i, work );
  394.      
  395.      mv( (char *)work, (char *) block );
  396. }
  397.  
  398. /*--------------------------------*/
  399.  
  400. short  Hx( c ) 
  401.   char c;
  402. {
  403.      if ( c >= '0' && c <= '9' ) {
  404.       return( c - '0' );
  405.      } else {
  406.       if ( c >= 'A' && c <= 'F' )
  407.            return( c - 'A' + 10 );
  408.       else if ( c >= 'a' && c <= 'f' )
  409.            return( c - 'a' + 10);
  410.       else
  411.            return( 0 );
  412.      }
  413. }
  414.  
  415.  
  416. /*--------------------------------*/
  417. /* Take a character string and convert it into two long ints 
  418. */
  419.  
  420. void HexToBin( In, Out ) 
  421.   char * In; 
  422.   unsigned long Out[];
  423. {
  424.      short i;
  425.      char * OutC;
  426.      int bytes[8];
  427.  
  428.  
  429.      for (i=0; i < 8; i++) 
  430.       bytes[i] = (Hx(In[i*2]) * 16 ) + Hx(In[i*2 + 1]);
  431.  
  432.      Out[0] = (bytes[0]*16777216) + (bytes[1]*65536) + (bytes[2]*256) + bytes[3];
  433.  
  434.      Out[1] = (bytes[4]*16777216) + (bytes[5]*65536) + (bytes[6]*256) + bytes[7];
  435.  
  436.      if (DEBUG)
  437.       printf("Output of HextoBin is %X%X\n", Out[0], Out[1]);
  438. }
  439.  
  440.  
  441. /*--------------------------------*/
  442.  
  443. decrypt( pwrd, key, out ) 
  444.   char * pwrd; 
  445.   char * key; 
  446.   unsigned long out[];
  447. {
  448.      short i;
  449.      unsigned long bpwrd[3], bkey[3];
  450.      char * OutC;
  451.      
  452.      if ( desinit() != 0 ) Abort("DES could ! init itself.\n");
  453.      
  454.      HexToBin( pwrd, bpwrd );
  455.      HexToBin( key, bkey );
  456.      setdeskey( ( char * ) bkey );
  457.      for ( i = 0; i <= 1; i++ )
  458.       out[ i ] = bpwrd[ i ];
  459.      dedes( out );
  460.      OutC = (char *) out;
  461.      OutC[ 8 ] = '\0';
  462.      if (DEBUG) {
  463.       printf("decrypt: key = %.8lX%.8lX\n", bkey[0], bkey[1] );
  464.       printf("input: %.8lX%.8lX, output = %.8lX%.8lX  '%s'\n",
  465.          bpwrd[0], bpwrd[1], out[0], out[1],(char *) out);
  466.      }
  467. }
  468.  
  469. /*--------------------------------*/
  470.  
  471. encrypt( pwrd, key, out )
  472.   char * pwrd; 
  473.   char * key; 
  474.   unsigned long out[];
  475. {
  476.      short i;
  477.      unsigned long bpwrd[3], bkey[3];
  478.      
  479.      if ( desinit() != 0 ) Abort("Error initializing DES.\n");
  480.      HexToBin( pwrd, bpwrd );
  481.      HexToBin( key, bkey );
  482.      setdeskey( (char *) bkey );
  483.      for ( i = 0; i <=1; i++ )
  484.       out[ i ] = bpwrd[ i ];
  485.      endes( out );
  486.      if (DEBUG) {
  487.       printf("encrypt: key = %.8lX%.8lX\n", bkey[0], bkey[1] );
  488.       printf("input: %.8lX%.8lX, output = %.8lX%.8lX\n",
  489.          bpwrd[0], bpwrd[1], out[0], out[1]);
  490.      }
  491. }
  492.  
  493.  
  494. #include "String.h"
  495. #include <stdio.h>
  496. #include <sys/types.h>
  497.  
  498. #include "gopherd.h"
  499. #include "tix.h"
  500. #include "command.h"
  501.  
  502. /*--------------------------------*/
  503. /** Test for a ticket 
  504.     Find out if the request has a ticket,
  505.  
  506.     If not, print out an error message on sockfd and exit 
  507. **/
  508.  
  509. PleaseAuthenticate(sockfd, string)
  510.   int  sockfd;
  511.   char *string;
  512. {
  513.      /*** Should be "gplus error...  oh well... ****/
  514.      
  515.      writestring(sockfd, "--2\r\n4 *UMNDES based auth required\r\nServer Requires Authenication\r\n");
  516.       closenet(sockfd);
  517.      return(0);
  518. }
  519.  
  520. TixObj *
  521. ValidTicket(sockfd, cmd)
  522.   int sockfd;
  523.   CMDobj *cmd;
  524. {
  525.      int fd;
  526.      TixArray *Tickets;
  527.      char *cp;
  528.      TixObj *tix, *ReturnTix;
  529.  
  530.      
  531.      Tickets = TIXAnew();
  532.      
  533.      fd = uopen(GDCgetTixfile(Config), O_RDWR, 0644);
  534.      TIXAfromFile(Tickets, fd);
  535.      
  536.      if (CMDgetCommand(cmd) != NULL && strcmp(CMDgetCommand(cmd), "!+TIX")==0) {
  537.       int i;
  538.       char outputline[512];
  539.       
  540.       
  541.       i = TIXAsearchUser(Tickets, CMDgetUser(cmd));
  542.       tix = TIXAgetEntry(Tickets, i);
  543.       
  544.       if (i <0) {
  545.            GplusError(sockfd, 1, "Sorry, you don't have an account...", NULL);
  546.            return(NULL);
  547.       }
  548.       
  549.       TIXrandomTicket(TIXAgetEntry(Tickets, i));
  550.       cp = TIXgetCryptedTicket(TIXAgetEntry(Tickets, i));
  551.  
  552.       sprintf(outputline, "+-1\r\n+INFO: 1%s\t\t%s\t%d\r\n+TIX: %s\r\n.\r\n", GDCgetSite(Config), GDCgetHostname(Config), GDCgetPort(Config), cp);
  553.       
  554.       writestring(sockfd, outputline);
  555.       TIXusedTicket(tix);
  556.       lseek(fd, 0 , SEEK_SET);
  557.       TIXAtoFile(Tickets, fd);
  558.       
  559.       TIXAdestroy(Tickets);
  560.       return(NULL);
  561.      } else {
  562.       /*** Validate the request ***/
  563.       int i;
  564.       
  565.       if (TIXAvalid(Tickets, CMDgetUser(cmd), CMDgetTicket(cmd)) == FALSE) {
  566.            AccessDenied(sockfd);
  567.            return(NULL);
  568.       }
  569.       i = TIXAsearchUser(Tickets, CMDgetUser(cmd));
  570.       tix = TIXAgetEntry(Tickets, i);
  571.       TIXusedTicket(tix);
  572.  
  573.       if (DEBUG)
  574.            printf("Ticket user is %s\n", TIXgetUser(tix));
  575.       ReturnTix = TIXnew();
  576.       TIXcpy(ReturnTix, tix);
  577.       if (DEBUG)
  578.            printf("Ticket user is %s\n", TIXgetUser(tix));
  579.       
  580.       lseek(fd, 0 , SEEK_SET);
  581.       TIXAtoFile(Tickets, fd);
  582.       TIXAdestroy(Tickets);
  583.       return(ReturnTix);
  584.      }
  585. }
  586.  
  587.  
  588. AccessDenied(sockfd)
  589.   int sockfd;
  590. {
  591.      GplusError(sockfd, 5, "*UMNDES", NULL);
  592.      writestring(sockfd, "--2\r\n5 *UMNDES based auth required\r\nServer Requires Authentication\r\n");
  593.      return(NULL);
  594. }
  595.